package androidx.fragment.app;

import android.animation.Animator;
import android.annotation.SuppressLint;
import android.app.Activity;
import android.content.ComponentCallbacks;
import android.content.Context;
import android.content.Intent;
import android.content.res.Configuration;
import android.content.res.Resources;
import android.os.Build.VERSION;
import android.os.Bundle;
import android.os.Looper;
import android.os.Parcel;
import android.os.Parcelable;
import android.util.AttributeSet;
import android.util.SparseArray;
import android.view.ContextMenu;
import android.view.ContextMenu.ContextMenuInfo;
import android.view.LayoutInflater;
import android.view.Menu;
import android.view.MenuInflater;
import android.view.MenuItem;
import android.view.View;
import android.view.View.OnCreateContextMenuListener;
import android.view.ViewGroup;
import android.view.animation.Animation;
import androidx.annotation.CallSuper;
import androidx.annotation.LayoutRes;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.annotation.RestrictTo;
import androidx.annotation.RestrictTo.d;
import androidx.annotation.StringRes;
import com.huawei.hms.framework.network.restclient.hwhttp.dns.DnsConfig;
import com.huawei.hwid.core.constants.HwAccountConstants;
import java.io.FileDescriptor;
import java.io.PrintWriter;
import java.util.UUID;
import o.fm;
import o.gx;
import o.LayoutInflaterCompatHC;
import o.FragmentManager;
import o.jv;
import o.jx;
import o.jy;
import o.kd;
import o.kf;
import o.kg;
import o.kp;
import o.kp.e;
import o.kq;
import o.kv;
import o.kx;
import o.la;
import o.ld;
import o.lg;
import o.lh;
import o.mr;
import o.my;
import o.na;

public class Fragment implements ComponentCallbacks, OnCreateContextMenuListener, kv, lg, my {
    static final Object ʻ = new Object();
    public String ʻॱ = null;
    public boolean ʼॱ;
    public boolean ʽॱ;
    public boolean ʾ;
    public boolean ʿ;
    public boolean ˈ;
    public Fragment ˉ;
    public jv ˊˊ;
    @NonNull
    public kd ˊˋ = new kd();
    @NonNull
    public String ˊॱ = UUID.randomUUID().toString();
    public kd ˊᐝ;
    private boolean ˋ;
    public int ˋˊ;
    public boolean ˋˋ;
    @Nullable
    public Boolean ˋॱ;
    public boolean ˋᐝ;
    public int ˌ;
    public int ˍ;
    public String ˎˎ;
    public boolean ˎˏ;
    @LayoutRes
    private int ˏ;
    public boolean ˏˎ;
    public ViewGroup ˏˏ;
    public SparseArray<Parcelable> ˏॱ;
    public boolean ˑ;
    public int ͺ = 0;
    public boolean ͺॱ = true;
    public View ـ;
    private Boolean ॱ = null;
    public boolean ॱʻ;
    public View ॱʼ;
    c ॱʽ;
    public Bundle ॱˊ;
    public int ॱˋ;
    Bundle ॱˎ;
    public boolean ॱͺ = true;
    public Fragment ॱᐝ;
    Runnable ᐝˊ = new Runnable(this) {
        final /* synthetic */ Fragment ˊ;

        {
            this.ˊ = r1;
        }

        public void run() {
            this.ˊ.ـ();
        }
    };
    LayoutInflater ᐝˋ;
    public boolean ᐝॱ;
    public float ᐝᐝ;
    public boolean ᐧ;
    public boolean ᐨ;
    @Nullable
    public kg ᶥ;
    public boolean ㆍ;
    kx ꓸ;
    public o.kp.c ꜞ = o.kp.c.RESUMED;
    public la<kv> ꜟ = new la();
    na ꞌ;

    public static class InstantiationException extends RuntimeException {
        public InstantiationException(@NonNull String str, @Nullable Exception exception) {
            super(str, exception);
        }
    }

    @SuppressLint({"BanParcelableUsage"})
    public static class SavedState implements Parcelable {
        @NonNull
        public static final Creator<SavedState> CREATOR = new ClassLoaderCreator<SavedState>() {
            public /* synthetic */ Object createFromParcel(Parcel parcel) {
                return ˋ(parcel);
            }

            public /* synthetic */ Object createFromParcel(Parcel parcel, ClassLoader classLoader) {
                return ˏ(parcel, classLoader);
            }

            public /* synthetic */ Object[] newArray(int i) {
                return ˋ(i);
            }

            public SavedState ˋ(Parcel parcel) {
                return new SavedState(parcel, null);
            }

            public SavedState ˏ(Parcel parcel, ClassLoader classLoader) {
                return new SavedState(parcel, classLoader);
            }

            public SavedState[] ˋ(int i) {
                return new SavedState[i];
            }
        };
        final Bundle ˏ;

        public SavedState(Bundle bundle) {
            this.ˏ = bundle;
        }

        SavedState(@NonNull Parcel parcel, @Nullable ClassLoader classLoader) {
            this.ˏ = parcel.readBundle();
            if (classLoader != null && this.ˏ != null) {
                this.ˏ.setClassLoader(classLoader);
            }
        }

        public int describeContents() {
            return 0;
        }

        public void writeToParcel(@NonNull Parcel parcel, int i) {
            parcel.writeBundle(this.ˏ);
        }
    }

    public interface a {
        void ˏ();

        void ॱ();
    }

    static class c {
        Object ʻ = Fragment.ʻ;
        boolean ʻॱ;
        Object ʼ = null;
        Object ʽ = null;
        Animator ˊ;
        Boolean ˊॱ;
        int ˋ;
        Object ˋॱ = null;
        int ˎ;
        View ˏ;
        fm ˏॱ = null;
        Boolean ͺ;
        int ॱ;
        Object ॱˊ = Fragment.ʻ;
        a ॱˋ;
        boolean ॱˎ;
        int ॱॱ;
        Object ᐝ = Fragment.ʻ;
        fm ᐝॱ = null;

        c() {
        }
    }

    @NonNull
    public kp ac_() {
        return this.ꓸ;
    }

    @NonNull
    public lh U_() {
        if (this.ˊᐝ != null) {
            return this.ˊᐝ.ˋ(this);
        }
        throw new IllegalStateException("Can't access ViewModels from detached fragment");
    }

    @NonNull
    public final mr V_() {
        return this.ꞌ.ˏ();
    }

    public Fragment() {
        ˊʻ();
    }

    private void ˊʻ() {
        this.ꓸ = new kx(this);
        this.ꞌ = na.ॱ(this);
        if (VERSION.SDK_INT >= 19) {
            this.ꓸ.ॱ(new kq(this) {
                final /* synthetic */ Fragment ˋ;

                {
                    this.ˋ = r1;
                }

                public void ˊ(@NonNull kv kvVar, @NonNull e eVar) {
                    if (eVar == e.ON_STOP && this.ˋ.ॱʼ != null) {
                        this.ˋ.ॱʼ.cancelPendingInputEvents();
                    }
                }
            });
        }
    }

    @NonNull
    @Deprecated
    public static Fragment ॱ(@NonNull Context context, @NonNull String str, @Nullable Bundle bundle) {
        try {
            Fragment fragment = (Fragment) jy.ˋ(context.getClassLoader(), str).getConstructor(new Class[0]).newInstance(new Object[0]);
            if (bundle != null) {
                bundle.setClassLoader(fragment.getClass().getClassLoader());
                fragment.ʼ(bundle);
            }
            return fragment;
        } catch (Exception e) {
            throw new InstantiationException("Unable to instantiate fragment " + str + ": make sure class name exists, is public, and has an empty constructor that is public", e);
        } catch (Exception e2) {
            throw new InstantiationException("Unable to instantiate fragment " + str + ": make sure class name exists, is public, and has an empty constructor that is public", e2);
        } catch (Exception e22) {
            throw new InstantiationException("Unable to instantiate fragment " + str + ": could not find Fragment constructor", e22);
        } catch (Exception e222) {
            throw new InstantiationException("Unable to instantiate fragment " + str + ": calling Fragment constructor caused an exception", e222);
        }
    }

    public final void ʻ(Bundle bundle) {
        if (this.ˏॱ != null) {
            this.ـ.restoreHierarchyState(this.ˏॱ);
            this.ˏॱ = null;
        }
        this.ˋ = false;
        ॱˊ(bundle);
        if (!this.ˋ) {
            throw new kf("Fragment " + this + " did not call through to super.onViewStateRestored()");
        } else if (this.ॱʼ != null) {
            this.ᶥ.ˊ(e.ON_CREATE);
        }
    }

    public final boolean ॱॱ() {
        return this.ˋˊ > 0;
    }

    public final boolean equals(@Nullable Object obj) {
        return super.equals(obj);
    }

    public final int hashCode() {
        return super.hashCode();
    }

    public String toString() {
        StringBuilder stringBuilder = new StringBuilder(DnsConfig.MAX_CACHE_ENTRIES);
        gx.ˎ(this, stringBuilder);
        stringBuilder.append(" (");
        stringBuilder.append(this.ˊॱ);
        stringBuilder.append(")");
        if (this.ˌ != 0) {
            stringBuilder.append(" id=0x");
            stringBuilder.append(Integer.toHexString(this.ˌ));
        }
        if (this.ˎˎ != null) {
            stringBuilder.append(HwAccountConstants.BLANK);
            stringBuilder.append(this.ˎˎ);
        }
        stringBuilder.append('}');
        return stringBuilder.toString();
    }

    @Nullable
    public final String ʽ() {
        return this.ˎˎ;
    }

    public void ʼ(@Nullable Bundle bundle) {
        if (this.ˊᐝ == null || !ͺ()) {
            this.ॱˎ = bundle;
            return;
        }
        throw new IllegalStateException("Fragment already added and state has been saved");
    }

    @Nullable
    public final Bundle ˊॱ() {
        return this.ॱˎ;
    }

    public final boolean ͺ() {
        if (this.ˊᐝ == null) {
            return false;
        }
        return this.ˊᐝ.ᐝ();
    }

    public void ˎ(@Nullable SavedState savedState) {
        if (this.ˊᐝ != null) {
            throw new IllegalStateException("Fragment already added");
        }
        Bundle bundle = (savedState == null || savedState.ˏ == null) ? null : savedState.ˏ;
        this.ॱˊ = bundle;
    }

    @Nullable
    public final Fragment ˋॱ() {
        if (this.ॱᐝ != null) {
            return this.ॱᐝ;
        }
        if (this.ˊᐝ == null || this.ʻॱ == null) {
            return null;
        }
        return (Fragment) this.ˊᐝ.ॱॱ.get(this.ʻॱ);
    }

    @Nullable
    public Context ॱˊ() {
        return this.ˊˊ == null ? null : this.ˊˊ.ˋॱ();
    }

    @NonNull
    public final Context ˏॱ() {
        Context ॱˊ = ॱˊ();
        if (ॱˊ != null) {
            return ॱˊ;
        }
        throw new IllegalStateException("Fragment " + this + " not attached to a context.");
    }

    @Nullable
    public final FragmentActivity ॱˋ() {
        return this.ˊˊ == null ? null : (FragmentActivity) this.ˊˊ.ʽ();
    }

    @NonNull
    public final FragmentActivity ॱˎ() {
        FragmentActivity ॱˋ = ॱˋ();
        if (ॱˋ != null) {
            return ॱˋ;
        }
        throw new IllegalStateException("Fragment " + this + " not attached to an activity.");
    }

    @Nullable
    public final Object ʻॱ() {
        return this.ˊˊ == null ? null : this.ˊˊ.ʻ();
    }

    @NonNull
    public final Resources ᐝॱ() {
        return ˏॱ().getResources();
    }

    @NonNull
    public final CharSequence ˊ(@StringRes int i) {
        return ᐝॱ().getText(i);
    }

    @NonNull
    public final String ॱ(@StringRes int i) {
        return ᐝॱ().getString(i);
    }

    @NonNull
    public final String ˎ(@StringRes int i, @Nullable Object... objArr) {
        return ᐝॱ().getString(i, objArr);
    }

    @Nullable
    public final FragmentManager ॱᐝ() {
        return this.ˊᐝ;
    }

    @NonNull
    public final FragmentManager ʿ() {
        FragmentManager ॱᐝ = ॱᐝ();
        if (ॱᐝ != null) {
            return ॱᐝ;
        }
        throw new IllegalStateException("Fragment " + this + " not associated with a fragment manager.");
    }

    @NonNull
    public final FragmentManager ʽॱ() {
        if (this.ˊˊ != null) {
            return this.ˊˋ;
        }
        throw new IllegalStateException("Fragment " + this + " has not been attached yet.");
    }

    @Nullable
    public final Fragment ˈ() {
        return this.ˉ;
    }

    public final boolean ʾ() {
        return this.ˊˊ != null && this.ᐝॱ;
    }

    public final boolean ʼॱ() {
        return this.ˋᐝ;
    }

    public final boolean ˉ() {
        return (!ʾ() || ˊᐝ() || this.ॱʼ == null || this.ॱʼ.getWindowToken() == null || this.ॱʼ.getVisibility() != 0) ? false : true;
    }

    public final boolean ˊᐝ() {
        return this.ˋˋ;
    }

    public void ॱ(boolean z) {
    }

    public void c_(boolean z) {
        this.ˑ = z;
        if (this.ˊᐝ == null) {
            this.ˎˏ = true;
        } else if (z) {
            this.ˊᐝ.ˎ(this);
        } else {
            this.ˊᐝ.ॱॱ(this);
        }
    }

    public final boolean ˊˋ() {
        return this.ˑ;
    }

    public void ˊ(boolean z) {
        if (this.ͺॱ != z) {
            this.ͺॱ = z;
            if (this.ˏˎ && ʾ() && !ˊᐝ()) {
                this.ˊˊ.ॱॱ();
            }
        }
    }

    @Deprecated
    public void a_(boolean z) {
        if (!this.ॱͺ && z && this.ͺ < 3 && this.ˊᐝ != null && ʾ() && this.ㆍ) {
            this.ˊᐝ.ᐝ(this);
        }
        this.ॱͺ = z;
        boolean z2 = this.ͺ < 3 && !z;
        this.ॱʻ = z2;
        if (this.ॱˊ != null) {
            this.ˋॱ = Boolean.valueOf(z);
        }
    }

    public void ˎ(@SuppressLint({"UnknownNullness"}) Intent intent) {
        ˊ(intent, null);
    }

    public void ˊ(@SuppressLint({"UnknownNullness"}) Intent intent, @Nullable Bundle bundle) {
        if (this.ˊˊ == null) {
            throw new IllegalStateException("Fragment " + this + " not attached to Activity");
        }
        this.ˊˊ.ˋ(this, intent, -1, bundle);
    }

    public void ˋ(@SuppressLint({"UnknownNullness"}) Intent intent, int i) {
        ˊ(intent, i, null);
    }

    public void ˊ(@SuppressLint({"UnknownNullness"}) Intent intent, int i, @Nullable Bundle bundle) {
        if (this.ˊˊ == null) {
            throw new IllegalStateException("Fragment " + this + " not attached to Activity");
        }
        this.ˊˊ.ˋ(this, intent, i, bundle);
    }

    public void ॱ(int i, int i2, @Nullable Intent intent) {
    }

    public void ॱ(int i, @NonNull String[] strArr, @NonNull int[] iArr) {
    }

    @NonNull
    public LayoutInflater ॱ(@Nullable Bundle bundle) {
        return ॱॱ(bundle);
    }

    @NonNull
    public final LayoutInflater ˋˊ() {
        if (this.ᐝˋ == null) {
            return ʽ(null);
        }
        return this.ᐝˋ;
    }

    @NonNull
    public LayoutInflater ʽ(@Nullable Bundle bundle) {
        this.ᐝˋ = ॱ(bundle);
        return this.ᐝˋ;
    }

    @NonNull
    @Deprecated
    @RestrictTo({d.ॱ})
    public LayoutInflater ॱॱ(@Nullable Bundle bundle) {
        if (this.ˊˊ == null) {
            throw new IllegalStateException("onGetLayoutInflater() cannot be executed until the Fragment is attached to the FragmentManager.");
        }
        LayoutInflater ˎ = this.ˊˊ.ˎ();
        LayoutInflaterCompatHC.setLayoutInfaltorFactory2(ˎ, this.ˊˋ.ˊˊ());
        return ˎ;
    }

    @CallSuper
    public void ˋ(@NonNull Context context, @NonNull AttributeSet attributeSet, @Nullable Bundle bundle) {
        this.ˋ = true;
        Activity ʽ = this.ˊˊ == null ? null : this.ˊˊ.ʽ();
        if (ʽ != null) {
            this.ˋ = false;
            ॱ(ʽ, attributeSet, bundle);
        }
    }

    @CallSuper
    @Deprecated
    public void ॱ(@NonNull Activity activity, @NonNull AttributeSet attributeSet, @Nullable Bundle bundle) {
        this.ˋ = true;
    }

    public void ˋ(@NonNull Fragment fragment) {
    }

    @CallSuper
    public void ॱ(@NonNull Context context) {
        this.ˋ = true;
        Activity ʽ = this.ˊˊ == null ? null : this.ˊˊ.ʽ();
        if (ʽ != null) {
            this.ˋ = false;
            ॱ(ʽ);
        }
    }

    @CallSuper
    @Deprecated
    public void ॱ(@NonNull Activity activity) {
        this.ˋ = true;
    }

    @Nullable
    public Animation ˏ(int i, boolean z, int i2) {
        return null;
    }

    @Nullable
    public Animator ˎ(int i, boolean z, int i2) {
        return null;
    }

    @CallSuper
    public void ˏ(@Nullable Bundle bundle) {
        this.ˋ = true;
        ᐝ(bundle);
        if (!this.ˊˋ.ˎ(1)) {
            this.ˊˋ.ॱᐝ();
        }
    }

    public void ᐝ(@Nullable Bundle bundle) {
        if (bundle != null) {
            Parcelable parcelable = bundle.getParcelable("android:support:fragments");
            if (parcelable != null) {
                this.ˊˋ.ˎ(parcelable);
                this.ˊˋ.ॱᐝ();
            }
        }
    }

    @Nullable
    public View ˋ(@NonNull LayoutInflater layoutInflater, @Nullable ViewGroup viewGroup, @Nullable Bundle bundle) {
        if (this.ˏ != 0) {
            return layoutInflater.inflate(this.ˏ, viewGroup, false);
        }
        return null;
    }

    public void ˊ(@NonNull View view, @Nullable Bundle bundle) {
    }

    @Nullable
    public View getView() {
        return this.ॱʼ;
    }

    @NonNull
    public final View ˊˊ() {
        View view = getView();
        if (view != null) {
            return view;
        }
        throw new IllegalStateException("Fragment " + this + " did not return a View from onCreateView() or this was called before onCreateView().");
    }

    @CallSuper
    public void ˊ(@Nullable Bundle bundle) {
        this.ˋ = true;
    }

    @CallSuper
    public void ॱˊ(@Nullable Bundle bundle) {
        this.ˋ = true;
    }

    @CallSuper
    public void ag_() {
        this.ˋ = true;
    }

    @CallSuper
    public void ˌ() {
        this.ˋ = true;
    }

    public void ˋ(@NonNull Bundle bundle) {
    }

    public void b_(boolean z) {
    }

    public void ॱॱ(boolean z) {
    }

    @CallSuper
    public void onConfigurationChanged(@NonNull Configuration configuration) {
        this.ˋ = true;
    }

    public void ᐝ(boolean z) {
    }

    @CallSuper
    public void ˋᐝ() {
        this.ˋ = true;
    }

    @CallSuper
    public void ʼ() {
        this.ˋ = true;
    }

    @CallSuper
    public void onLowMemory() {
        this.ˋ = true;
    }

    @CallSuper
    public void ᐝ() {
        this.ˋ = true;
    }

    @CallSuper
    public void ˎˎ() {
        this.ˋ = true;
    }

    public void ˍ() {
        ˊʻ();
        this.ˊॱ = UUID.randomUUID().toString();
        this.ᐝॱ = false;
        this.ʼॱ = false;
        this.ʿ = false;
        this.ʽॱ = false;
        this.ˈ = false;
        this.ˋˊ = 0;
        this.ˊᐝ = null;
        this.ˊˋ = new kd();
        this.ˊˊ = null;
        this.ˌ = 0;
        this.ˍ = 0;
        this.ˎˎ = null;
        this.ˋˋ = false;
        this.ˋᐝ = false;
    }

    @CallSuper
    public void ˎ() {
        this.ˋ = true;
    }

    public void ˏ(@NonNull Menu menu, @NonNull MenuInflater menuInflater) {
    }

    public void ˊ(@NonNull Menu menu) {
    }

    public void ˋˋ() {
    }

    public boolean ˊ(@NonNull MenuItem menuItem) {
        return false;
    }

    public void ˋ(@NonNull Menu menu) {
    }

    public void onCreateContextMenu(@NonNull ContextMenu contextMenu, @NonNull View view, @Nullable ContextMenuInfo contextMenuInfo) {
        ॱˎ().onCreateContextMenu(contextMenu, view, contextMenuInfo);
    }

    public boolean ˎ(@NonNull MenuItem menuItem) {
        return false;
    }

    @Nullable
    public Object ˎˏ() {
        if (this.ॱʽ == null) {
            return null;
        }
        return this.ॱʽ.ʼ;
    }

    @Nullable
    public Object ˏˏ() {
        if (this.ॱʽ == null) {
            return null;
        }
        return this.ॱʽ.ᐝ == ʻ ? ˎˏ() : this.ॱʽ.ᐝ;
    }

    @Nullable
    public Object ˏˎ() {
        if (this.ॱʽ == null) {
            return null;
        }
        return this.ॱʽ.ʽ;
    }

    @Nullable
    public Object ˑ() {
        if (this.ॱʽ == null) {
            return null;
        }
        return this.ॱʽ.ʻ == ʻ ? ˏˎ() : this.ॱʽ.ʻ;
    }

    @Nullable
    public Object ͺॱ() {
        if (this.ॱʽ == null) {
            return null;
        }
        return this.ॱʽ.ˋॱ;
    }

    @Nullable
    public Object ॱʼ() {
        if (this.ॱʽ == null) {
            return null;
        }
        return this.ॱʽ.ॱˊ == ʻ ? ͺॱ() : this.ॱʽ.ॱˊ;
    }

    public boolean ॱͺ() {
        if (this.ॱʽ == null || this.ॱʽ.ˊॱ == null) {
            return true;
        }
        return this.ॱʽ.ˊॱ.booleanValue();
    }

    public boolean ॱʻ() {
        if (this.ॱʽ == null || this.ॱʽ.ͺ == null) {
            return true;
        }
        return this.ॱʽ.ͺ.booleanValue();
    }

    public void ـ() {
        if (this.ˊᐝ == null || this.ˊᐝ.ˋॱ == null) {
            ˉॱ().ॱˎ = false;
        } else if (Looper.myLooper() != this.ˊᐝ.ˋॱ.ˏॱ().getLooper()) {
            this.ˊᐝ.ˋॱ.ˏॱ().postAtFrontOfQueue(new Runnable(this) {
                final /* synthetic */ Fragment ॱ;

                {
                    this.ॱ = r1;
                }

                public void run() {
                    this.ॱ.ॱʽ();
                }
            });
        } else {
            ॱʽ();
        }
    }

    void ॱʽ() {
        a aVar = null;
        if (this.ॱʽ != null) {
            this.ॱʽ.ॱˎ = false;
            a aVar2 = this.ॱʽ.ॱˋ;
            this.ॱʽ.ॱˋ = null;
            aVar = aVar2;
        }
        if (aVar != null) {
            aVar.ॱ();
        }
    }

    public void ˎ(@NonNull String str, @Nullable FileDescriptor fileDescriptor, @NonNull PrintWriter printWriter, @Nullable String[] strArr) {
        printWriter.print(str);
        printWriter.print("mFragmentId=#");
        printWriter.print(Integer.toHexString(this.ˌ));
        printWriter.print(" mContainerId=#");
        printWriter.print(Integer.toHexString(this.ˍ));
        printWriter.print(" mTag=");
        printWriter.println(this.ˎˎ);
        printWriter.print(str);
        printWriter.print("mState=");
        printWriter.print(this.ͺ);
        printWriter.print(" mWho=");
        printWriter.print(this.ˊॱ);
        printWriter.print(" mBackStackNesting=");
        printWriter.println(this.ˋˊ);
        printWriter.print(str);
        printWriter.print("mAdded=");
        printWriter.print(this.ᐝॱ);
        printWriter.print(" mRemoving=");
        printWriter.print(this.ʼॱ);
        printWriter.print(" mFromLayout=");
        printWriter.print(this.ʿ);
        printWriter.print(" mInLayout=");
        printWriter.println(this.ʽॱ);
        printWriter.print(str);
        printWriter.print("mHidden=");
        printWriter.print(this.ˋˋ);
        printWriter.print(" mDetached=");
        printWriter.print(this.ˋᐝ);
        printWriter.print(" mMenuVisible=");
        printWriter.print(this.ͺॱ);
        printWriter.print(" mHasMenu=");
        printWriter.println(this.ˏˎ);
        printWriter.print(str);
        printWriter.print("mRetainInstance=");
        printWriter.print(this.ˑ);
        printWriter.print(" mUserVisibleHint=");
        printWriter.println(this.ॱͺ);
        if (this.ˊᐝ != null) {
            printWriter.print(str);
            printWriter.print("mFragmentManager=");
            printWriter.println(this.ˊᐝ);
        }
        if (this.ˊˊ != null) {
            printWriter.print(str);
            printWriter.print("mHost=");
            printWriter.println(this.ˊˊ);
        }
        if (this.ˉ != null) {
            printWriter.print(str);
            printWriter.print("mParentFragment=");
            printWriter.println(this.ˉ);
        }
        if (this.ॱˎ != null) {
            printWriter.print(str);
            printWriter.print("mArguments=");
            printWriter.println(this.ॱˎ);
        }
        if (this.ॱˊ != null) {
            printWriter.print(str);
            printWriter.print("mSavedFragmentState=");
            printWriter.println(this.ॱˊ);
        }
        if (this.ˏॱ != null) {
            printWriter.print(str);
            printWriter.print("mSavedViewState=");
            printWriter.println(this.ˏॱ);
        }
        Fragment ˋॱ = ˋॱ();
        if (ˋॱ != null) {
            printWriter.print(str);
            printWriter.print("mTarget=");
            printWriter.print(ˋॱ);
            printWriter.print(" mTargetRequestCode=");
            printWriter.println(this.ॱˋ);
        }
        if (ʹ() != 0) {
            printWriter.print(str);
            printWriter.print("mNextAnim=");
            printWriter.println(ʹ());
        }
        if (this.ˏˏ != null) {
            printWriter.print(str);
            printWriter.print("mContainer=");
            printWriter.println(this.ˏˏ);
        }
        if (this.ॱʼ != null) {
            printWriter.print(str);
            printWriter.print("mView=");
            printWriter.println(this.ॱʼ);
        }
        if (this.ـ != null) {
            printWriter.print(str);
            printWriter.print("mInnerView=");
            printWriter.println(this.ॱʼ);
        }
        if (ʻᐝ() != null) {
            printWriter.print(str);
            printWriter.print("mAnimatingAway=");
            printWriter.println(ʻᐝ());
            printWriter.print(str);
            printWriter.print("mStateAfterAnimating=");
            printWriter.println(ʻˊ());
        }
        if (ॱˊ() != null) {
            ld.ˎ(this).ˎ(str, fileDescriptor, printWriter, strArr);
        }
        printWriter.print(str);
        printWriter.println("Child " + this.ˊˋ + ":");
        this.ˊˋ.ˎ(str + "  ", fileDescriptor, printWriter, strArr);
    }

    @Nullable
    public Fragment ˋ(@NonNull String str) {
        return str.equals(this.ˊॱ) ? this : this.ˊˋ.ˊ(str);
    }

    public void ᐝˋ() {
        this.ˊˋ.ॱ(this.ˊˊ, new jx(this) {
            final /* synthetic */ Fragment ˎ;

            {
                this.ˎ = r1;
            }

            @Nullable
            public View ˊ(int i) {
                if (this.ˎ.ॱʼ != null) {
                    return this.ˎ.ॱʼ.findViewById(i);
                }
                throw new IllegalStateException("Fragment " + this + " does not have a view");
            }

            public boolean d_() {
                return this.ˎ.ॱʼ != null;
            }
        }, this);
        this.ˋ = false;
        ॱ(this.ˊˊ.ˋॱ());
        if (!this.ˋ) {
            throw new kf("Fragment " + this + " did not call through to super.onAttach()");
        }
    }

    public void ͺ(Bundle bundle) {
        this.ˊˋ.ॱˎ();
        this.ͺ = 1;
        this.ˋ = false;
        this.ꞌ.ˏ(bundle);
        ˏ(bundle);
        this.ㆍ = true;
        if (this.ˋ) {
            this.ꓸ.ˊ(e.ON_CREATE);
            return;
        }
        throw new kf("Fragment " + this + " did not call through to super.onCreate()");
    }

    public void ˎ(@NonNull LayoutInflater layoutInflater, @Nullable ViewGroup viewGroup, @Nullable Bundle bundle) {
        this.ˊˋ.ॱˎ();
        this.ʾ = true;
        this.ᶥ = new kg();
        this.ॱʼ = ˋ(layoutInflater, viewGroup, bundle);
        if (this.ॱʼ != null) {
            this.ᶥ.ˊ();
            this.ꜟ.ॱ(this.ᶥ);
        } else if (this.ᶥ.ॱ()) {
            throw new IllegalStateException("Called getViewLifecycleOwner() but onCreateView() returned null");
        } else {
            this.ᶥ = null;
        }
    }

    public void ˏॱ(Bundle bundle) {
        this.ˊˋ.ॱˎ();
        this.ͺ = 2;
        this.ˋ = false;
        ˊ(bundle);
        if (this.ˋ) {
            this.ˊˋ.ʻॱ();
            return;
        }
        throw new kf("Fragment " + this + " did not call through to super.onActivityCreated()");
    }

    public void ᐨ() {
        this.ˊˋ.ॱˎ();
        this.ˊˋ.ॱˊ();
        this.ͺ = 3;
        this.ˋ = false;
        ag_();
        if (this.ˋ) {
            this.ꓸ.ˊ(e.ON_START);
            if (this.ॱʼ != null) {
                this.ᶥ.ˊ(e.ON_START);
            }
            this.ˊˋ.ᐝॱ();
            return;
        }
        throw new kf("Fragment " + this + " did not call through to super.onStart()");
    }

    public void ᐝˊ() {
        this.ˊˋ.ॱˎ();
        this.ˊˋ.ॱˊ();
        this.ͺ = 4;
        this.ˋ = false;
        ˌ();
        if (this.ˋ) {
            this.ꓸ.ˊ(e.ON_RESUME);
            if (this.ॱʼ != null) {
                this.ᶥ.ˊ(e.ON_RESUME);
            }
            this.ˊˋ.ॱˋ();
            this.ˊˋ.ॱˊ();
            return;
        }
        throw new kf("Fragment " + this + " did not call through to super.onResume()");
    }

    public void ᐝᐝ() {
        this.ˊˋ.ॱˎ();
    }

    public void ᐧ() {
        boolean ˏ = this.ˊᐝ.ˏ(this);
        if (this.ॱ == null || this.ॱ.booleanValue() != ˏ) {
            this.ॱ = Boolean.valueOf(ˏ);
            ᐝ(ˏ);
            this.ˊˋ.ˊˋ();
        }
    }

    public void ʼ(boolean z) {
        b_(z);
        this.ˊˋ.ॱ(z);
    }

    public void ʻ(boolean z) {
        ॱॱ(z);
        this.ˊˋ.ˊ(z);
    }

    public void ˋ(@NonNull Configuration configuration) {
        onConfigurationChanged(configuration);
        this.ˊˋ.ˏ(configuration);
    }

    public void ㆍ() {
        onLowMemory();
        this.ˊˋ.ʽॱ();
    }

    public boolean ˋ(@NonNull Menu menu, @NonNull MenuInflater menuInflater) {
        int i = 0;
        if (this.ˋˋ) {
            return false;
        }
        if (this.ˏˎ && this.ͺॱ) {
            i = 1;
            ˏ(menu, menuInflater);
        }
        return i | this.ˊˋ.ˊ(menu, menuInflater);
    }

    public boolean ˏ(@NonNull Menu menu) {
        int i = 0;
        if (this.ˋˋ) {
            return false;
        }
        if (this.ˏˎ && this.ͺॱ) {
            i = 1;
            ˊ(menu);
        }
        return i | this.ˊˋ.ˊ(menu);
    }

    public boolean ˏ(@NonNull MenuItem menuItem) {
        if (this.ˋˋ || ((!this.ˏˎ || !this.ͺॱ || !ˊ(menuItem)) && !this.ˊˋ.ˊ(menuItem))) {
            return false;
        }
        return true;
    }

    public boolean ˋ(@NonNull MenuItem menuItem) {
        if (this.ˋˋ || (!ˎ(menuItem) && !this.ˊˋ.ˏ(menuItem))) {
            return false;
        }
        return true;
    }

    public void ˎ(@NonNull Menu menu) {
        if (!this.ˋˋ) {
            if (this.ˏˎ && this.ͺॱ) {
                ˋ(menu);
            }
            this.ˊˋ.ॱ(menu);
        }
    }

    public void ˊॱ(Bundle bundle) {
        ˋ(bundle);
        this.ꞌ.ˎ(bundle);
        Parcelable ˊॱ = this.ˊˋ.ˊॱ();
        if (ˊॱ != null) {
            bundle.putParcelable("android:support:fragments", ˊॱ);
        }
    }

    public void ꓸ() {
        this.ˊˋ.ʿ();
        if (this.ॱʼ != null) {
            this.ᶥ.ˊ(e.ON_PAUSE);
        }
        this.ꓸ.ˊ(e.ON_PAUSE);
        this.ͺ = 3;
        this.ˋ = false;
        ˋᐝ();
        if (!this.ˋ) {
            throw new kf("Fragment " + this + " did not call through to super.onPause()");
        }
    }

    public void ꜟ() {
        this.ˊˋ.ʾ();
        if (this.ॱʼ != null) {
            this.ᶥ.ˊ(e.ON_STOP);
        }
        this.ꓸ.ˊ(e.ON_STOP);
        this.ͺ = 2;
        this.ˋ = false;
        ʼ();
        if (!this.ˋ) {
            throw new kf("Fragment " + this + " did not call through to super.onStop()");
        }
    }

    public void ᶥ() {
        this.ˊˋ.ˈ();
        if (this.ॱʼ != null) {
            this.ᶥ.ˊ(e.ON_DESTROY);
        }
        this.ͺ = 1;
        this.ˋ = false;
        ᐝ();
        if (this.ˋ) {
            ld.ˎ(this).ॱ();
            this.ʾ = false;
            return;
        }
        throw new kf("Fragment " + this + " did not call through to super.onDestroyView()");
    }

    public void ꜞ() {
        this.ˊˋ.ʼॱ();
        this.ꓸ.ˊ(e.ON_DESTROY);
        this.ͺ = 0;
        this.ˋ = false;
        this.ㆍ = false;
        ˎˎ();
        if (!this.ˋ) {
            throw new kf("Fragment " + this + " did not call through to super.onDestroy()");
        }
    }

    public void ﹳ() {
        this.ˋ = false;
        ˎ();
        this.ᐝˋ = null;
        if (!this.ˋ) {
            throw new kf("Fragment " + this + " did not call through to super.onDetach()");
        } else if (!this.ˊˋ.ॱॱ()) {
            this.ˊˋ.ʼॱ();
            this.ˊˋ = new kd();
        }
    }

    public void ˋ(a aVar) {
        ˉॱ();
        if (aVar != this.ॱʽ.ॱˋ) {
            if (aVar == null || this.ॱʽ.ॱˋ == null) {
                if (this.ॱʽ.ॱˎ) {
                    this.ॱʽ.ॱˋ = aVar;
                }
                if (aVar != null) {
                    aVar.ˏ();
                    return;
                }
                return;
            }
            throw new IllegalStateException("Trying to set a replacement startPostponedEnterTransition on " + this);
        }
    }

    private c ˉॱ() {
        if (this.ॱʽ == null) {
            this.ॱʽ = new c();
        }
        return this.ॱʽ;
    }

    public int ʹ() {
        if (this.ॱʽ == null) {
            return 0;
        }
        return this.ॱʽ.ॱ;
    }

    public void ˎ(int i) {
        if (this.ॱʽ != null || i != 0) {
            ˉॱ().ॱ = i;
        }
    }

    public int ꞌ() {
        if (this.ॱʽ == null) {
            return 0;
        }
        return this.ॱʽ.ˎ;
    }

    public void ˊ(int i, int i2) {
        if (this.ॱʽ != null || i != 0 || i2 != 0) {
            ˉॱ();
            this.ॱʽ.ˎ = i;
            this.ॱʽ.ॱॱ = i2;
        }
    }

    public int ﾟ() {
        if (this.ॱʽ == null) {
            return 0;
        }
        return this.ॱʽ.ॱॱ;
    }

    public fm ﾞ() {
        if (this.ॱʽ == null) {
            return null;
        }
        return this.ॱʽ.ˏॱ;
    }

    public fm ʼˋ() {
        if (this.ॱʽ == null) {
            return null;
        }
        return this.ॱʽ.ᐝॱ;
    }

    public View ʻᐝ() {
        if (this.ॱʽ == null) {
            return null;
        }
        return this.ॱʽ.ˏ;
    }

    public void ˏ(View view) {
        ˉॱ().ˏ = view;
    }

    public void ˏ(Animator animator) {
        ˉॱ().ˊ = animator;
    }

    public Animator ʼˊ() {
        if (this.ॱʽ == null) {
            return null;
        }
        return this.ॱʽ.ˊ;
    }

    public int ʻˊ() {
        if (this.ॱʽ == null) {
            return 0;
        }
        return this.ॱʽ.ˋ;
    }

    public void ˏ(int i) {
        ˉॱ().ˋ = i;
    }

    public boolean ʻˋ() {
        if (this.ॱʽ == null) {
            return false;
        }
        return this.ॱʽ.ॱˎ;
    }

    public boolean ʽˋ() {
        if (this.ॱʽ == null) {
            return false;
        }
        return this.ॱʽ.ʻॱ;
    }

    public void ʽ(boolean z) {
        ˉॱ().ʻॱ = z;
    }
}
